package product;

import java.util.concurrent.*;

public class Test {

    public static ExecutorService executor = Executors.newFixedThreadPool(10);

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        /*CompletableFuture.runAsync(() -> {
            System.out.println(Thread.currentThread().getName());
        }, executor);*/
//        CompletableFuture<Integer> supplyAsync =
//                // 创建异步对象，supplyAsync具有返回值，runAsync没有返回值。
//                CompletableFuture.supplyAsync(() -> {
//                            System.out.println("当前线程：" + Thread.currentThread().getId());
//                            int i = 10 / 2;
//                            System.out.println(i);
//                            return i;
//                        }, executor)
//                        // 计算完成时的回调
//                        .whenCompleteAsync((res, error) -> {
//                            System.out.println("结果是：" + res);
//                            System.out.println("异常是：" + error);
//                        })
//                        // 感知异常，并修改返回的异常。
//                        .exceptionally(throwable -> 10)
//                        // 方法执行完成后的处理 R apply(T t,U u)
//                        .handle((res, error) -> {
//                            if (res != null) {
//                                return res * 3;
//                            }
//                            if (error != null) {
//                                return 0;
//                            }
//                            return 0;
//                        });
//        System.out.println("最终结果是：" + supplyAsync.get());
        // 创建异步对象，supplyAsync具有返回值，runAsync没有返回值。
        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
                    System.out.println("当前线程：" + Thread.currentThread().getId());
                    int i = 10 / 2;
                    System.out.println(i);
                    return i;
                }, executor)
                // 不能接收上一个任务的结果，也没有返回值。
//                .thenRunAsync(() -> {
//                    System.out.println("执行b任务");
//                }, executor);
                // 可以接收上一步的处理结果，没有返回值。
//                .thenAcceptAsync((res) -> {
//                    System.out.println("上一步的处理结果是：" + res);
//                }, executor);
                // 可以接收上一步的处理结果，有返回值。
                .thenApplyAsync((res) -> {
                    return res + 2;
                }, executor);
        System.out.println("最终的处理结果：" + future.get());

        CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
            System.out.println("任务2执行了");
            return 1;
        }, executor);

        // 合并两个任务，runAfterBothAsync获取不到两个合并任务的结果，也没有返回值。
//        future.runAfterBothAsync(future1, () -> {
//            System.out.println("两个任务执行合并后，任务3开始执行了");
//        }, executor);
        // 合并两个任务,thenAcceptBothAsync可以获取到两个任务的返回值，但没有返回值。
//        future.thenAcceptBothAsync(future1,(res1,res2)->{
//            System.out.println("第一个任务的返回值:"+res1+"->第二个任务的返回值:"+res2);
//        },executor);
        // 合并两个任务,thenCombineAsync可以获取到两个任务的返回值，也有返回值。
//        CompletableFuture<Integer> future2 = future.thenCombineAsync(future1, (res1, res2) -> {
//            return res1 + res2;
//        }, executor);
//        System.out.println("两个任务的结果相加：" + future2.get());

        // 合并两个任务，只要其中一个任务完成，就执行接下来的任务，runAfterEitherAsync获取不到两个合并任务的结果，也没有返回值。
//        future.runAfterEitherAsync(future1, () -> {
//            System.out.println("任务3开始。。。");
//        }, executor);
        // acceptEitherAsync获取先执行完的任务结果，没有返回值。
        future.acceptEitherAsync(future1, (res1) -> {
            System.out.println("先完成任务的结果：" + res1);
        }, executor);
        // applyToEitherAsync获取先执行完的任务结果，有返回值。
        future.applyToEitherAsync(future1, (res1) -> {
            return res1 + 3;
        }, executor);



    }
}
